package antlr;
// Generated from non_ho_niente_da_mettermi.g4 by ANTLR 4.1
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;

@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
public class non_ho_niente_da_mettermiParser extends Parser {
	protected static final DFA[] _decisionToDFA;
	protected static final PredictionContextCache _sharedContextCache =
		new PredictionContextCache();
	public static final int
		EQUAL=1, LOADCLOSET=2, SEMICOLON=3, COLON=4, DOT=5, IS=6, NOT=7, IN=8, 
		LS_B=9, RS_B=10, COMMA=11, EXCLUDE=12, INCLUDE=13, ONLY=14, CATEGORY=15, 
		IF=16, THEN=17, ELSE=18, LC_B=19, RC_B=20, OUTFIT=21, IDEAS=22, FOR=23, 
		WHEN=24, WHERE=25, SUGGEST=26, STRING=27, PATH=28, WS=29;
	public static final String[] tokenNames = {
		"<INVALID>", "'='", "'loadCloset'", "';'", "':'", "'.'", "'is'", "'not'", 
		"'in'", "'['", "']'", "','", "'exclude'", "'include'", "'only'", "'category'", 
		"'if'", "'then'", "'else'", "'{'", "'}'", "'outfit'", "'ideas'", "'for'", 
		"'when'", "'where'", "'suggest'", "STRING", "PATH", "WS"
	};
	public static final int
		RULE_scope = 0, RULE_closet = 1, RULE_color_list = 2, RULE_statement = 3, 
		RULE_expression = 4, RULE_list = 5, RULE_filter = 6, RULE_category_Rule = 7, 
		RULE_block = 8, RULE_event = 9, RULE_outfit_ideas = 10;
	public static final String[] ruleNames = {
		"scope", "closet", "color_list", "statement", "expression", "list", "filter", 
		"category_Rule", "block", "event", "outfit_ideas"
	};

	@Override
	public String getGrammarFileName() { return "non_ho_niente_da_mettermi.g4"; }

	@Override
	public String[] getTokenNames() { return tokenNames; }

	@Override
	public String[] getRuleNames() { return ruleNames; }

	@Override
	public ATN getATN() { return _ATN; }

	public non_ho_niente_da_mettermiParser(TokenStream input) {
		super(input);
		_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
	}
	public static class ScopeContext extends ParserRuleContext {
		public TerminalNode EOF() { return getToken(non_ho_niente_da_mettermiParser.EOF, 0); }
		public ClosetContext closet() {
			return getRuleContext(ClosetContext.class,0);
		}
		public Color_listContext color_list(int i) {
			return getRuleContext(Color_listContext.class,i);
		}
		public EventContext event(int i) {
			return getRuleContext(EventContext.class,i);
		}
		public List<Color_listContext> color_list() {
			return getRuleContexts(Color_listContext.class);
		}
		public Outfit_ideasContext outfit_ideas() {
			return getRuleContext(Outfit_ideasContext.class,0);
		}
		public List<EventContext> event() {
			return getRuleContexts(EventContext.class);
		}
		public ScopeContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_scope; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof non_ho_niente_da_mettermiVisitor ) return ((non_ho_niente_da_mettermiVisitor<? extends T>)visitor).visitScope(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ScopeContext scope() throws RecognitionException {
		ScopeContext _localctx = new ScopeContext(_ctx, getState());
		enterRule(_localctx, 0, RULE_scope);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(22); closet();
			setState(26);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==STRING) {
				{
				{
				setState(23); color_list();
				}
				}
				setState(28);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(30); 
			_errHandler.sync(this);
			_la = _input.LA(1);
			do {
				{
				{
				setState(29); event();
				}
				}
				setState(32); 
				_errHandler.sync(this);
				_la = _input.LA(1);
			} while ( _la==WHEN );
			setState(34); outfit_ideas();
			setState(35); match(EOF);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ClosetContext extends ParserRuleContext {
		public TerminalNode SEMICOLON() { return getToken(non_ho_niente_da_mettermiParser.SEMICOLON, 0); }
		public TerminalNode LOADCLOSET() { return getToken(non_ho_niente_da_mettermiParser.LOADCLOSET, 0); }
		public TerminalNode PATH() { return getToken(non_ho_niente_da_mettermiParser.PATH, 0); }
		public TerminalNode COLON() { return getToken(non_ho_niente_da_mettermiParser.COLON, 0); }
		public ClosetContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_closet; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof non_ho_niente_da_mettermiVisitor ) return ((non_ho_niente_da_mettermiVisitor<? extends T>)visitor).visitCloset(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ClosetContext closet() throws RecognitionException {
		ClosetContext _localctx = new ClosetContext(_ctx, getState());
		enterRule(_localctx, 2, RULE_closet);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(37); match(LOADCLOSET);
			setState(38); match(COLON);
			setState(39); match(PATH);
			setState(40); match(SEMICOLON);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Color_listContext extends ParserRuleContext {
		public TerminalNode SEMICOLON() { return getToken(non_ho_niente_da_mettermiParser.SEMICOLON, 0); }
		public ListContext list() {
			return getRuleContext(ListContext.class,0);
		}
		public TerminalNode EQUAL() { return getToken(non_ho_niente_da_mettermiParser.EQUAL, 0); }
		public TerminalNode STRING() { return getToken(non_ho_niente_da_mettermiParser.STRING, 0); }
		public Color_listContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_color_list; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof non_ho_niente_da_mettermiVisitor ) return ((non_ho_niente_da_mettermiVisitor<? extends T>)visitor).visitColor_list(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Color_listContext color_list() throws RecognitionException {
		Color_listContext _localctx = new Color_listContext(_ctx, getState());
		enterRule(_localctx, 4, RULE_color_list);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(42); match(STRING);
			setState(43); match(EQUAL);
			setState(44); list();
			setState(45); match(SEMICOLON);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class StatementContext extends ParserRuleContext {
		public FilterContext filter() {
			return getRuleContext(FilterContext.class,0);
		}
		public ExpressionContext expression() {
			return getRuleContext(ExpressionContext.class,0);
		}
		public StatementContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_statement; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof non_ho_niente_da_mettermiVisitor ) return ((non_ho_niente_da_mettermiVisitor<? extends T>)visitor).visitStatement(this);
			else return visitor.visitChildren(this);
		}
	}

	public final StatementContext statement() throws RecognitionException {
		StatementContext _localctx = new StatementContext(_ctx, getState());
		enterRule(_localctx, 6, RULE_statement);
		try {
			setState(49);
			switch (_input.LA(1)) {
			case STRING:
				enterOuterAlt(_localctx, 1);
				{
				setState(47); expression();
				}
				break;
			case EXCLUDE:
			case INCLUDE:
				enterOuterAlt(_localctx, 2);
				{
				setState(48); filter();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ExpressionContext extends ParserRuleContext {
		public TerminalNode IN() { return getToken(non_ho_niente_da_mettermiParser.IN, 0); }
		public TerminalNode SEMICOLON() { return getToken(non_ho_niente_da_mettermiParser.SEMICOLON, 0); }
		public TerminalNode STRING(int i) {
			return getToken(non_ho_niente_da_mettermiParser.STRING, i);
		}
		public ListContext list() {
			return getRuleContext(ListContext.class,0);
		}
		public TerminalNode DOT() { return getToken(non_ho_niente_da_mettermiParser.DOT, 0); }
		public TerminalNode NOT() { return getToken(non_ho_niente_da_mettermiParser.NOT, 0); }
		public TerminalNode IS() { return getToken(non_ho_niente_da_mettermiParser.IS, 0); }
		public List<TerminalNode> STRING() { return getTokens(non_ho_niente_da_mettermiParser.STRING); }
		public ExpressionContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_expression; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof non_ho_niente_da_mettermiVisitor ) return ((non_ho_niente_da_mettermiVisitor<? extends T>)visitor).visitExpression(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ExpressionContext expression() throws RecognitionException {
		ExpressionContext _localctx = new ExpressionContext(_ctx, getState());
		enterRule(_localctx, 8, RULE_expression);
		int _la;
		try {
			setState(76);
			switch ( getInterpreter().adaptivePredict(_input,8,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(51); match(STRING);
				setState(54);
				_la = _input.LA(1);
				if (_la==DOT) {
					{
					setState(52); match(DOT);
					setState(53); match(STRING);
					}
				}

				setState(56); match(IS);
				setState(58);
				_la = _input.LA(1);
				if (_la==NOT) {
					{
					setState(57); match(NOT);
					}
				}

				setState(60); match(STRING);
				setState(61); match(SEMICOLON);
				}
				break;

			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(62); match(STRING);
				setState(65);
				_la = _input.LA(1);
				if (_la==DOT) {
					{
					setState(63); match(DOT);
					setState(64); match(STRING);
					}
				}

				setState(68);
				_la = _input.LA(1);
				if (_la==NOT) {
					{
					setState(67); match(NOT);
					}
				}

				setState(70); match(IN);
				setState(73);
				switch (_input.LA(1)) {
				case LS_B:
					{
					setState(71); list();
					}
					break;
				case STRING:
					{
					setState(72); match(STRING);
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				setState(75); match(SEMICOLON);
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ListContext extends ParserRuleContext {
		public TerminalNode STRING(int i) {
			return getToken(non_ho_niente_da_mettermiParser.STRING, i);
		}
		public List<TerminalNode> COMMA() { return getTokens(non_ho_niente_da_mettermiParser.COMMA); }
		public TerminalNode RS_B() { return getToken(non_ho_niente_da_mettermiParser.RS_B, 0); }
		public List<TerminalNode> STRING() { return getTokens(non_ho_niente_da_mettermiParser.STRING); }
		public TerminalNode COMMA(int i) {
			return getToken(non_ho_niente_da_mettermiParser.COMMA, i);
		}
		public TerminalNode LS_B() { return getToken(non_ho_niente_da_mettermiParser.LS_B, 0); }
		public ListContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_list; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof non_ho_niente_da_mettermiVisitor ) return ((non_ho_niente_da_mettermiVisitor<? extends T>)visitor).visitList(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ListContext list() throws RecognitionException {
		ListContext _localctx = new ListContext(_ctx, getState());
		enterRule(_localctx, 10, RULE_list);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(78); match(LS_B);
			setState(79); match(STRING);
			setState(84);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==COMMA) {
				{
				{
				setState(80); match(COMMA);
				setState(81); match(STRING);
				}
				}
				setState(86);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(87); match(RS_B);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class FilterContext extends ParserRuleContext {
		public TerminalNode INCLUDE() { return getToken(non_ho_niente_da_mettermiParser.INCLUDE, 0); }
		public TerminalNode EXCLUDE() { return getToken(non_ho_niente_da_mettermiParser.EXCLUDE, 0); }
		public TerminalNode SEMICOLON() { return getToken(non_ho_niente_da_mettermiParser.SEMICOLON, 0); }
		public ListContext list() {
			return getRuleContext(ListContext.class,0);
		}
		public TerminalNode ONLY() { return getToken(non_ho_niente_da_mettermiParser.ONLY, 0); }
		public FilterContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_filter; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof non_ho_niente_da_mettermiVisitor ) return ((non_ho_niente_da_mettermiVisitor<? extends T>)visitor).visitFilter(this);
			else return visitor.visitChildren(this);
		}
	}

	public final FilterContext filter() throws RecognitionException {
		FilterContext _localctx = new FilterContext(_ctx, getState());
		enterRule(_localctx, 12, RULE_filter);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(92);
			switch (_input.LA(1)) {
			case EXCLUDE:
				{
				setState(89); match(EXCLUDE);
				}
				break;
			case INCLUDE:
				{
				setState(90); match(INCLUDE);
				setState(91); match(ONLY);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			setState(94); list();
			setState(95); match(SEMICOLON);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Category_RuleContext extends ParserRuleContext {
		public List<StatementContext> statement() {
			return getRuleContexts(StatementContext.class);
		}
		public TerminalNode CATEGORY() { return getToken(non_ho_niente_da_mettermiParser.CATEGORY, 0); }
		public TerminalNode RC_B() { return getToken(non_ho_niente_da_mettermiParser.RC_B, 0); }
		public TerminalNode LC_B() { return getToken(non_ho_niente_da_mettermiParser.LC_B, 0); }
		public StatementContext statement(int i) {
			return getRuleContext(StatementContext.class,i);
		}
		public TerminalNode STRING() { return getToken(non_ho_niente_da_mettermiParser.STRING, 0); }
		public Category_RuleContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_category_Rule; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof non_ho_niente_da_mettermiVisitor ) return ((non_ho_niente_da_mettermiVisitor<? extends T>)visitor).visitCategory_Rule(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Category_RuleContext category_Rule() throws RecognitionException {
		Category_RuleContext _localctx = new Category_RuleContext(_ctx, getState());
		enterRule(_localctx, 14, RULE_category_Rule);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(97); match(CATEGORY);
			setState(98); match(STRING);
			setState(99); match(LC_B);
			setState(103);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << EXCLUDE) | (1L << INCLUDE) | (1L << STRING))) != 0)) {
				{
				{
				setState(100); statement();
				}
				}
				setState(105);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(106); match(RC_B);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class BlockContext extends ParserRuleContext {
		public List<StatementContext> statement() {
			return getRuleContexts(StatementContext.class);
		}
		public List<Category_RuleContext> category_Rule() {
			return getRuleContexts(Category_RuleContext.class);
		}
		public TerminalNode RC_B() { return getToken(non_ho_niente_da_mettermiParser.RC_B, 0); }
		public Category_RuleContext category_Rule(int i) {
			return getRuleContext(Category_RuleContext.class,i);
		}
		public TerminalNode LC_B() { return getToken(non_ho_niente_da_mettermiParser.LC_B, 0); }
		public StatementContext statement(int i) {
			return getRuleContext(StatementContext.class,i);
		}
		public BlockContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_block; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof non_ho_niente_da_mettermiVisitor ) return ((non_ho_niente_da_mettermiVisitor<? extends T>)visitor).visitBlock(this);
			else return visitor.visitChildren(this);
		}
	}

	public final BlockContext block() throws RecognitionException {
		BlockContext _localctx = new BlockContext(_ctx, getState());
		enterRule(_localctx, 16, RULE_block);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(108); match(LC_B);
			setState(112);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << EXCLUDE) | (1L << INCLUDE) | (1L << STRING))) != 0)) {
				{
				{
				setState(109); statement();
				}
				}
				setState(114);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(118);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==CATEGORY) {
				{
				{
				setState(115); category_Rule();
				}
				}
				setState(120);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(121); match(RC_B);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class EventContext extends ParserRuleContext {
		public TerminalNode WHERE() { return getToken(non_ho_niente_da_mettermiParser.WHERE, 0); }
		public List<TerminalNode> SEMICOLON() { return getTokens(non_ho_niente_da_mettermiParser.SEMICOLON); }
		public TerminalNode STRING(int i) {
			return getToken(non_ho_niente_da_mettermiParser.STRING, i);
		}
		public TerminalNode SEMICOLON(int i) {
			return getToken(non_ho_niente_da_mettermiParser.SEMICOLON, i);
		}
		public BlockContext block() {
			return getRuleContext(BlockContext.class,0);
		}
		public TerminalNode SUGGEST() { return getToken(non_ho_niente_da_mettermiParser.SUGGEST, 0); }
		public List<TerminalNode> STRING() { return getTokens(non_ho_niente_da_mettermiParser.STRING); }
		public TerminalNode WHEN() { return getToken(non_ho_niente_da_mettermiParser.WHEN, 0); }
		public EventContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_event; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof non_ho_niente_da_mettermiVisitor ) return ((non_ho_niente_da_mettermiVisitor<? extends T>)visitor).visitEvent(this);
			else return visitor.visitChildren(this);
		}
	}

	public final EventContext event() throws RecognitionException {
		EventContext _localctx = new EventContext(_ctx, getState());
		enterRule(_localctx, 18, RULE_event);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(123); match(WHEN);
			setState(124); match(STRING);
			setState(125); match(SEMICOLON);
			setState(126); match(WHERE);
			setState(127); match(STRING);
			setState(128); match(SEMICOLON);
			setState(129); match(SUGGEST);
			setState(130); block();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class Outfit_ideasContext extends ParserRuleContext {
		public TerminalNode STRING(int i) {
			return getToken(non_ho_niente_da_mettermiParser.STRING, i);
		}
		public TerminalNode FOR() { return getToken(non_ho_niente_da_mettermiParser.FOR, 0); }
		public TerminalNode OUTFIT() { return getToken(non_ho_niente_da_mettermiParser.OUTFIT, 0); }
		public List<TerminalNode> STRING() { return getTokens(non_ho_niente_da_mettermiParser.STRING); }
		public TerminalNode IDEAS() { return getToken(non_ho_niente_da_mettermiParser.IDEAS, 0); }
		public Outfit_ideasContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_outfit_ideas; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof non_ho_niente_da_mettermiVisitor ) return ((non_ho_niente_da_mettermiVisitor<? extends T>)visitor).visitOutfit_ideas(this);
			else return visitor.visitChildren(this);
		}
	}

	public final Outfit_ideasContext outfit_ideas() throws RecognitionException {
		Outfit_ideasContext _localctx = new Outfit_ideasContext(_ctx, getState());
		enterRule(_localctx, 20, RULE_outfit_ideas);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(132); match(OUTFIT);
			setState(133); match(IDEAS);
			setState(134); match(FOR);
			setState(135); match(STRING);
			setState(136); match(STRING);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static final String _serializedATN =
		"\3\uacf5\uee8c\u4f5d\u8b0d\u4a45\u78bd\u1b2f\u3378\3\37\u008d\4\2\t\2"+
		"\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13"+
		"\t\13\4\f\t\f\3\2\3\2\7\2\33\n\2\f\2\16\2\36\13\2\3\2\6\2!\n\2\r\2\16"+
		"\2\"\3\2\3\2\3\2\3\3\3\3\3\3\3\3\3\3\3\4\3\4\3\4\3\4\3\4\3\5\3\5\5\5\64"+
		"\n\5\3\6\3\6\3\6\5\69\n\6\3\6\3\6\5\6=\n\6\3\6\3\6\3\6\3\6\3\6\5\6D\n"+
		"\6\3\6\5\6G\n\6\3\6\3\6\3\6\5\6L\n\6\3\6\5\6O\n\6\3\7\3\7\3\7\3\7\7\7"+
		"U\n\7\f\7\16\7X\13\7\3\7\3\7\3\b\3\b\3\b\5\b_\n\b\3\b\3\b\3\b\3\t\3\t"+
		"\3\t\3\t\7\th\n\t\f\t\16\tk\13\t\3\t\3\t\3\n\3\n\7\nq\n\n\f\n\16\nt\13"+
		"\n\3\n\7\nw\n\n\f\n\16\nz\13\n\3\n\3\n\3\13\3\13\3\13\3\13\3\13\3\13\3"+
		"\13\3\13\3\13\3\f\3\f\3\f\3\f\3\f\3\f\3\f\2\r\2\4\6\b\n\f\16\20\22\24"+
		"\26\2\2\u008f\2\30\3\2\2\2\4\'\3\2\2\2\6,\3\2\2\2\b\63\3\2\2\2\nN\3\2"+
		"\2\2\fP\3\2\2\2\16^\3\2\2\2\20c\3\2\2\2\22n\3\2\2\2\24}\3\2\2\2\26\u0086"+
		"\3\2\2\2\30\34\5\4\3\2\31\33\5\6\4\2\32\31\3\2\2\2\33\36\3\2\2\2\34\32"+
		"\3\2\2\2\34\35\3\2\2\2\35 \3\2\2\2\36\34\3\2\2\2\37!\5\24\13\2 \37\3\2"+
		"\2\2!\"\3\2\2\2\" \3\2\2\2\"#\3\2\2\2#$\3\2\2\2$%\5\26\f\2%&\7\2\2\3&"+
		"\3\3\2\2\2\'(\7\4\2\2()\7\6\2\2)*\7\36\2\2*+\7\5\2\2+\5\3\2\2\2,-\7\35"+
		"\2\2-.\7\3\2\2./\5\f\7\2/\60\7\5\2\2\60\7\3\2\2\2\61\64\5\n\6\2\62\64"+
		"\5\16\b\2\63\61\3\2\2\2\63\62\3\2\2\2\64\t\3\2\2\2\658\7\35\2\2\66\67"+
		"\7\7\2\2\679\7\35\2\28\66\3\2\2\289\3\2\2\29:\3\2\2\2:<\7\b\2\2;=\7\t"+
		"\2\2<;\3\2\2\2<=\3\2\2\2=>\3\2\2\2>?\7\35\2\2?O\7\5\2\2@C\7\35\2\2AB\7"+
		"\7\2\2BD\7\35\2\2CA\3\2\2\2CD\3\2\2\2DF\3\2\2\2EG\7\t\2\2FE\3\2\2\2FG"+
		"\3\2\2\2GH\3\2\2\2HK\7\n\2\2IL\5\f\7\2JL\7\35\2\2KI\3\2\2\2KJ\3\2\2\2"+
		"LM\3\2\2\2MO\7\5\2\2N\65\3\2\2\2N@\3\2\2\2O\13\3\2\2\2PQ\7\13\2\2QV\7"+
		"\35\2\2RS\7\r\2\2SU\7\35\2\2TR\3\2\2\2UX\3\2\2\2VT\3\2\2\2VW\3\2\2\2W"+
		"Y\3\2\2\2XV\3\2\2\2YZ\7\f\2\2Z\r\3\2\2\2[_\7\16\2\2\\]\7\17\2\2]_\7\20"+
		"\2\2^[\3\2\2\2^\\\3\2\2\2_`\3\2\2\2`a\5\f\7\2ab\7\5\2\2b\17\3\2\2\2cd"+
		"\7\21\2\2de\7\35\2\2ei\7\25\2\2fh\5\b\5\2gf\3\2\2\2hk\3\2\2\2ig\3\2\2"+
		"\2ij\3\2\2\2jl\3\2\2\2ki\3\2\2\2lm\7\26\2\2m\21\3\2\2\2nr\7\25\2\2oq\5"+
		"\b\5\2po\3\2\2\2qt\3\2\2\2rp\3\2\2\2rs\3\2\2\2sx\3\2\2\2tr\3\2\2\2uw\5"+
		"\20\t\2vu\3\2\2\2wz\3\2\2\2xv\3\2\2\2xy\3\2\2\2y{\3\2\2\2zx\3\2\2\2{|"+
		"\7\26\2\2|\23\3\2\2\2}~\7\32\2\2~\177\7\35\2\2\177\u0080\7\5\2\2\u0080"+
		"\u0081\7\33\2\2\u0081\u0082\7\35\2\2\u0082\u0083\7\5\2\2\u0083\u0084\7"+
		"\34\2\2\u0084\u0085\5\22\n\2\u0085\25\3\2\2\2\u0086\u0087\7\27\2\2\u0087"+
		"\u0088\7\30\2\2\u0088\u0089\7\31\2\2\u0089\u008a\7\35\2\2\u008a\u008b"+
		"\7\35\2\2\u008b\27\3\2\2\2\20\34\"\638<CFKNV^irx";
	public static final ATN _ATN =
		ATNSimulator.deserialize(_serializedATN.toCharArray());
	static {
		_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
		for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
			_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
		}
	}
}